def use_list():
    # 定义
    kong_list = []  # 定义一个空列表
    print(type(kong_list))
    my_list = ["aaa", "bbb", "ccc", "ddd"]
    # 增
    my_list.append("zzz")  # 在末尾追加数据
    print(my_list)
    my_list.insert(0, "jjj")  # 在指定下标位置插入数据
    print(my_list)
    temp_list = [2, 4, 6, 1, 3, 5]  # 列表生成式
    my_list.extend(temp_list)  # 将temp_list追加到my_list后面
    print(my_list)
    # 删(列表内的元素是挨着的，因此删操作的平均时间复杂度为O（n），因为要移动元素)
    my_list.remove("bbb")  # 删除首次出现的指定数据，若指定元素不存在会报错
    print(my_list)
    my_list.pop()  # 删除末尾数据
    print(my_list)
    my_list.pop(0)  # 删除指定下标位置的元素
    print(my_list)
    # temp_list.clear()  将列表清空
    # print(temp_list)
    # 改
    my_list[0] = "kkk"
    print(my_list)
    # 查
    print(my_list[2])  # 按下标查得元素
    print(my_list.index("ccc"))  # 按元素查得下标（首次出现的）查不到会报错
    print(my_list.count("ccc"))  # 查某元素在列表中出现的次数
    # 排序
    print(temp_list)
    temp_list.reverse()  # 将列表逆置
    print(temp_list)
    temp_list.sort()  # 对列表进行排序（默认是升序排序）python中是归并排序
    print(temp_list)
    temp_list.sort(reverse=True)  # 对列标进行排序（降序）
    print(temp_list)
    # 列表生成式
    a = [x for x in range(10)]
    print(a)
    a = [j for i in range(5) for j in range(i)]  # 2个for循环
    print(a)
    a = [[col * row for col in range(3)] for row in range(3)]  # 二维列表
    print(a, a[1], a[1][2])
    b = [j for x in a for j in x]  # 二维转一维
    print(b)
    a = [x for x in range(10) if x % 2 == 0]  # 使用if
    print(a)
    a = [x if x % 2 == 0 else x ** 2 for x in range(10)]  # 使用if else
    print(a)


def use_tuple():
    # 定义
    my_tuple = (1, 2, 3, 3, "小明")
    yes_tuple = (1,)  # 一个元素的元组怎么定义
    # 查
    for item in my_tuple:  # 遍历
        print(item)
    print(my_tuple.index(2))  # 查指定元素下标
    print(my_tuple.count(3))  # 查指定元素个数
    # 元组应用于格式化字符串
    my_str = "%d%d%d%d%s" % my_tuple
    print(my_str)
    print("%d%d%d%d%s" % my_tuple)


def use_dict():
    # 定义(字典中不能有相同的键)
    my_dict = {"a": 1, "b": 2, "c": 3}
    kong_dict = {}  # 定义空字典
    print(type(my_dict))
    # 增(若键不存在的增加，若键存在则修改)
    my_dict["d"] = 4
    my_dict["a"] = 0
    print(my_dict)
    # 删
    my_dict.pop("a")  # pop有返回值就是删的键对应的值
    print(my_dict)
    my_dict.clear()  # clear清空字典，即变为了空字典
    print(my_dict)
    # 改(update方法将另一个字典合并到自身，若存在相同键则修改)
    new_dict = {"小明": 1.5, "小壮": 1.8, "b": 11}
    print(new_dict)
    my_dict.update(new_dict)
    print(my_dict)
    # 查
    print(my_dict["b"])  # 下标取值
    # 遍历（可指定遍历键、值、键值对）
    for item in my_dict:  # 每次遍历item取的是键（相当于for item in my_dict.keys():）
        print(item)
    for item in my_dict.values():  # 每次遍历item取的是值
        print(item)
    for k, v in my_dict.items():  # 每次遍历k、v依次取键、值
        print(k, v)
    # 复合（列表内套字典）
    card_list = [
        {"name": "张三",
         "qq": "12345",
         "phone": "110"},
        {"name": "李四",
         "qq": "54321",
         "phone": "10086"}
    ]
    for card in card_list:
        print(card)


def use_set():
    # 定义(集合内不存在相同元素，即使定义时有它也会自动去重)
    my_set = {11, 4, 3, 2}
    print(my_set)
    kone_set = set()  # 定义空集合
    print(type(kone_set))
    new_set = my_set.copy()  # copy方法后new_set和my_set的地址不同
    same_set = my_set  # 赋值后x和my_set的地址相同
    print(id(my_set))
    print(id(new_set))
    print(id(same_set))
    # 增
    my_set.add("小明")
    print(my_set)
    # 删
    my_set.discard(11)  # 删除指定元素
    print(my_set)
    # 查(按值查找若存在返回True，不存在返回False)
    print("小明" in my_set)
    print(33 in my_set)
    # 集合操作
    x = {1, 2, 3, 4}
    y = {1, 2, 5, 6}
    z = x.union(y)  # 取并集（x | y)
    print(z)
    z = x.intersection(y)  # 取交集(x & y)(支持取多个集合的交集：z=x.intersection(m,n))
    print(z)
    z = x.difference(y)  # 取差集（返回新的集合此处是x-y（去掉x中同样在y中存在的元素））
    print(z)
    x.difference_update(y)  # 在原集合上取差集，相当于是改，并不返回新的集合()
    print(x)
    z = x.symmetric_difference(y)  # 返回两个集合中不重复的元素集合(x ^ y)(相当于并集-交集)
    print(z)
    # 集合的运算符操作: - | & ^
    # 集合生成式
    my_set = {x for x in "zxvjkl1212"}
    print(my_set)
    my_set = {x for x in "zxvjkl1212" if x not in "12"}
    print(my_set)


def use_str():
    # 定义
    my_str = "abc*"
    # 改
    x = "3cd23cd2cd"
    y = x.replace("cd", "CD", 2)  # 将‘’替换为‘’，替换几次
    print(y)
    # 查
    x = "234adc34"
    print(x.find("23", 0, 7))  # 可指定查找范围（默认是全部），找到则返回起始下标，没找到返回-1
    print(x.index("23"))  # 查找子串出现位置，找到返回起始下标，没找到会报错
    print(x.count("34"))  # 统计子串出现次数
    # 判断类型
    x = "abc*"
    print(x.isalnum())  # 非空字符串内是否只有字母和数字(空字符串返回False)
    y = "1256"
    print(y.isdecimal())  # 非空字符串内是否只有数字(空字符串返回False)
    # 拆分和连接（字符串与列表的相互转化）
    x = "ab*12*小明"
    print(x.split("*"))  # 以*为分隔符拆分字符串（默认以空格）。返回值为列表，各个字串作为列表元素。
    x = 'abc\nbcd\nefg'
    print(x.splitlines())  # 以换行作为分隔符拆分字符串
    x = ['add', 'b', 'c']
    y = "".join(x)  # 将列表中的元素以‘’接起来,返回一个字符串（注意这个列表中的元素必须是字符串型的）
    print(y)  # 相当于print(''.join(x))
    print(type(y))
    # 切片:左闭右开(适用于有序的容器：字符串、列表、元组)
    x = "0123456789"
    y = x[2:5]  # 截取下标[2,5)的字符串
    print(y)  # 相当于print（x[2:5]）
    print(x[2:])  # 截取下标[2之后的字符串
    print(x[:6])  # 截取下标[开始,6)的字符串
    print(x[:])  # 截取完整的字符串
    print(x[::2])  # 第三个参数表示每几个元素截取（默认为1即连续截取）
    print(x[-1])  # 下标-1表示倒数第1个元素
    print(x[2:-1])  # 截取下标[2,-1)的字符串
    print(x[-2:])  # 截取下标[-2之后的字符串
    print(x[::-1])  # 逆序截取字符串（字符串的逆序）(注意采用-1切片时区间左大右小)


if __name__ == '__main__':
    use_tuple()
    use_dict()
    use_set()
    use_str()
    use_list()
